Ribbon 是 Netflix 开源的 **客户端负载均衡器**，通常与 Eureka 结合使用，用于在微服务架构中实现服务调用的负载均衡。以下是一个简单的 Ribbon 示例，展示如何使用 Ribbon 实现服务调用。

---

### **1. 环境准备**
确保你已经有一个 Eureka Server 和一个或多个 Eureka Client（微服务）。如果没有，可以参考上一节的 Eureka 示例。

---

### **2. 添加 Ribbon 依赖**
在 `pom.xml` 中添加 Ribbon 依赖：

```xml
<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
```

---

### **3. 配置 Ribbon**
Ribbon 默认会从 Eureka 获取服务实例列表，因此需要确保 Eureka Client 的配置正确。

在 `application.yml` 中配置 Eureka Client：

```yaml
server:
  port: 8082 # 当前微服务的端口

spring:
  application:
    name: ribbon-client-service # 当前微服务的名称

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/ # Eureka Server 地址
```

---

### **4. 使用 Ribbon 实现负载均衡**
Ribbon 可以通过 `RestTemplate` 或 `Feign` 实现负载均衡。以下是使用 `RestTemplate` 的示例。

#### **4.1 配置 RestTemplate**
在启动类中配置 `RestTemplate`，并添加 `@LoadBalanced` 注解以启用 Ribbon 的负载均衡功能：

```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class RibbonClientApplication {
    public static void main(String[] args) {
        SpringApplication.run(RibbonClientApplication.class, args);
    }

    @Bean
    @LoadBalanced // 启用 Ribbon 负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
```

#### **4.2 实现服务调用**
编写一个服务类，使用 `RestTemplate` 调用其他微服务：

```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class HelloService {

    @Autowired
    private RestTemplate restTemplate;

    public String callHelloService() {
        // 使用服务名称（而不是具体的 URL）调用服务
        return restTemplate.getForObject("http://eureka-client-service/hello", String.class);
    }
}
```

#### **4.3 添加 REST 接口**
在控制器中调用 `HelloService`：

```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private HelloService helloService;

    @GetMapping("/call-hello")
    public String callHello() {
        return helloService.callHelloService();
    }
}
```

---

### **5. 测试**
1. 启动 Eureka Server。
2. 启动多个 Eureka Client 实例（例如，修改 `server.port` 为 `8081` 和 `8083`）。
3. 启动 Ribbon Client 应用。
4. 访问 `http://localhost:8082/call-hello`，Ribbon 会自动将请求负载均衡到不同的 Eureka Client 实例。

---

### **6. 总结**
- Ribbon 是一个客户端负载均衡器，通常与 Eureka 结合使用。
- 通过 `@LoadBalanced` 注解，可以让 `RestTemplate` 支持 Ribbon 的负载均衡功能。
- Ribbon 默认的负载均衡策略是轮询（Round Robin），你也可以自定义负载均衡策略。

---

### **7. 扩展**
- **自定义负载均衡策略**：通过实现 `IRule` 接口，可以自定义 Ribbon 的负载均衡策略。
- **结合 Feign**：Feign 是一个声明式的 HTTP 客户端，内置了 Ribbon 的负载均衡功能，使用起来更加简洁。
- **结合 Hystrix**：通过 Hystrix 实现服务调用的熔断和降级，提高系统的容错能力。

以下是一个结合 Feign 的示例：

#### **7.1 添加 Feign 依赖**
```xml
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
```

#### **7.2 启用 Feign**
在启动类上添加 `@EnableFeignClients` 注解：

```java
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients
public class RibbonClientApplication {
    public static void main(String[] args) {
        SpringApplication.run(RibbonClientApplication.class, args);
    }
}
```

#### **7.3 使用 Feign 调用服务**
定义一个 Feign 客户端接口：

```java
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "eureka-client-service") // 指定服务名称
public interface HelloClient {

    @GetMapping("/hello") // 调用服务的接口路径
    String callHello();
}
```

在控制器中使用 Feign 客户端：

```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private HelloClient helloClient;

    @GetMapping("/call-hello")
    public String callHello() {
        return helloClient.callHello();
    }
}
```

通过 Feign，代码更加简洁，且内置了 Ribbon 的负载均衡功能。